package org.example.config.i18nconfig;

import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.executor.resultset.ResultSetHandler;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.plugin.Intercepts;
import org.apache.ibatis.plugin.Invocation;
import org.apache.ibatis.plugin.Plugin;
import org.apache.ibatis.plugin.Signature;
import org.example.utils.I18nUtil;
import org.springframework.stereotype.Component;

import java.lang.reflect.Field;
import java.sql.Statement;
import java.util.List;
import java.util.Properties;

/**
 * MyBatis结果拦截器，自动处理查询结果的i18n翻译
 *
 * 拦截MyBatis的ResultSetHandler，在查询结果返回前自动进行i18n翻译
 *
 * 优势：
 * - 全局拦截，无需修改Mapper或Service代码
 * - 支持注解标记需要翻译的字段
 * - 支持嵌套对象和集合的翻译
 * - 性能高效，只在必要时进行翻译
 */
@Slf4j
@Component
@Intercepts({
        @Signature(type = ResultSetHandler.class, method = "handleResultSets", args = {Statement.class})
})
public class I18nResultInterceptor implements Interceptor {


    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        // 执行原始查询
        Object result = invocation.proceed();

        // 对结果进行i18n处理
        if (result != null) {
            processI18nTranslation(result);
        }

        return result;
    }

    /**
     * 处理i18n翻译
     */
    private void processI18nTranslation(Object result) {
        if (result instanceof List) {
            // 处理列表结果
            List<?> list = (List<?>) result;
            for (Object item : list) {
                if (item != null) {
                    translateObject(item);
                }
            }
        } else {
            // 处理单个对象结果
            translateObject(result);
        }
    }

    /**
     * 翻译单个对象
     */
    private void translateObject(Object obj) {
        if (obj == null) {
            return;
        }

        Class<?> clazz = obj.getClass();

        // 跳过基本类型和包装类型
        if (isSimpleType(clazz)) {
            return;
        }

        try {
            Field[] fields = clazz.getDeclaredFields();
            for (Field field : fields) {
                field.setAccessible(true);

                // 检查字段是否需要翻译
                if (shouldTranslateField(field)) {
                    Object value = field.get(obj);
                    if (value instanceof String) {
                        String translatedValue = translateIfNeeded((String) value);
                        field.set(obj, translatedValue);
                    }
                }
            }
        } catch (Exception e) {
            log.warn("翻译对象时出错: {}", e.getMessage());
        }
    }

    /**
     * 判断字段是否需要翻译
     */
    private boolean shouldTranslateField(Field field) {
        return field.isAnnotationPresent(I18nField.class);
        // 方式1：检查是否有@I18nField注解
//        if (field.isAnnotationPresent(I18nField.class)) {
//            return true;
//        }

        // 方式2：根据字段名判断（常见的需要翻译的字段）
//        String fieldName = field.getName().toLowerCase();
//        return fieldName.equals("name")
//                || fieldName.equals("description")
//                || fieldName.equals("title")
//                || fieldName.equals("label")
//                || fieldName.equals("displayname");
    }

    /**
     * 翻译逻辑
     */
    private String translateIfNeeded(String value) {
        if (value == null || value.trim().isEmpty()) {
            return value;
        }

        try {
            // 判断是否需要翻译（包含中文字符或标准i18n键）
            if (containsChinese(value) || isStandardI18nKey(value)) {
                String translated = I18nUtil.getMessage(value);
                // 如果翻译成功且与原值不同，说明找到了翻译
                if (translated != null && !translated.isEmpty() && !translated.equals(value)) {
                    log.debug("拦截器I18n翻译: {} -> {}", value, translated);
                    return translated;
                }
            }
        } catch (Exception e) {
            log.warn("拦截器I18n翻译失败: {}, 错误: {}", value, e.getMessage());
        }

        return value;
    }

    /**
     * 检查字符串是否包含中文字符
     */
    private boolean containsChinese(String str) {
        if (str == null || str.isEmpty()) {
            return false;
        }
        for (char c : str.toCharArray()) {
            if (Character.UnicodeScript.of(c) == Character.UnicodeScript.HAN) {
                return true;
            }
        }
        return false;
    }

    /**
     * 检查是否是标准i18n键格式
     */
    private boolean isStandardI18nKey(String value) {
        return value.contains(".") && Character.isLetter(value.charAt(0)) && !containsChinese(value);
    }

    /**
     * 判断是否是简单类型
     */
    private boolean isSimpleType(Class<?> clazz) {
        return clazz.isPrimitive() || clazz.equals(String.class) || clazz.equals(Integer.class)
                || clazz.equals(Long.class) || clazz.equals(Double.class) || clazz.equals(Float.class)
                || clazz.equals(Boolean.class)
                || clazz.getPackage() != null && clazz.getPackage().getName().startsWith("java.");
    }

    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }

    @Override
    public void setProperties(Properties properties) {
        // 可以通过配置文件设置一些参数
    }
}